```html
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>WeakHashMap 深度解析 | Java 弱引用映射详解</title>
    <link rel="stylesheet" href="https://cdn.staticfile.org/font-awesome/6.4.0/css/all.min.css">
    <link rel="stylesheet" href="https://cdn.staticfile.org/tailwindcss/2.2.19/tailwind.min.css">
    <link href="https://fonts.googleapis.com/css2?family=Noto+Serif+SC:wght@400;500;600;700&family=Noto+Sans+SC:wght@300;400;500;700&display=swap" rel="stylesheet">
    <script src="https://cdn.jsdelivr.net/npm/mermaid@latest/dist/mermaid.min.js"></script>
    <style>
        body {
            font-family: 'Noto Sans SC', Tahoma, Arial, Roboto, "Droid Sans", "Helvetica Neue", "Droid Sans Fallback", "Heiti SC", "Hiragino Sans GB", Simsun, sans-serif;
            color: #333;
            line-height: 1.8;
        }
        h1, h2, h3, h4, h5, h6 {
            font-family: 'Noto Serif SC', serif;
            font-weight: 600;
            color: #2d3748;
            margin-top: 1.5em;
        }
        .hero-gradient {
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
        }
        .code-block {
            background-color: #f8fafc;
            border-left: 4px solid #667eea;
            padding: 1.5rem;
            margin: 1.5rem 0;
            border-radius: 0.375rem;
            overflow-x: auto;
        }
        .feature-card:hover {
            transform: translateY(-5px);
            box-shadow: 0 10px 25px rgba(0, 0, 0, 0.1);
        }
        .visualization-card {
            transition: all 0.3s ease;
        }
        .visualization-card:hover {
            box-shadow: 0 8px 30px rgba(0, 0, 0, 0.12);
        }
        .nav-link {
            position: relative;
        }
        .nav-link::after {
            content: '';
            position: absolute;
            bottom: -2px;
            left: 0;
            width: 0;
            height: 2px;
            background-color: #667eea;
            transition: width 0.3s ease;
        }
        .nav-link:hover::after {
            width: 100%;
        }
        .drop-cap::first-letter {
            float: left;
            font-size: 3.5em;
            line-height: 0.8;
            margin: 0.1em 0.1em 0 0;
            font-weight: 700;
            color: #667eea;
        }
    </style>
</head>
<body class="bg-gray-50">
    <!-- Navigation -->
    <nav class="bg-white shadow-sm fixed w-full z-10">
        <div class="max-w-6xl mx-auto px-4 sm:px-6 lg:px-8">
            <div class="flex justify-between h-16">
                <div class="flex items-center">
                    <span class="text-xl font-bold text-indigo-600">Java 核心技术</span>
                </div>
                <div class="hidden md:flex items-center space-x-8">
                    <a href="#intro" class="nav-link text-gray-700 hover:text-indigo-600">简介</a>
                    <a href="#principle" class="nav-link text-gray-700 hover:text-indigo-600">工作原理</a>
                    <a href="#scenarios" class="nav-link text-gray-700 hover:text-indigo-600">应用场景</a>
                    <a href="#pros-cons" class="nav-link text-gray-700 hover:text-indigo-600">优劣分析</a>
                </div>
            </div>
        </div>
    </nav>

    <!-- Hero Section -->
    <section class="hero-gradient text-white pt-32 pb-20 md:pt-40 md:pb-28">
        <div class="max-w-5xl mx-auto px-4 sm:px-6 lg:px-8">
            <div class="text-center">
                <h1 class="text-4xl md:text-5xl font-bold mb-6 leading-tight">深入理解 WeakHashMap</h1>
                <p class="text-xl md:text-2xl font-light max-w-3xl mx-auto mb-8">Java 弱引用映射的核心原理与应用实践</p>
                <div class="flex justify-center space-x-4">
                    <a href="#intro" class="px-6 py-3 bg-white text-indigo-600 font-medium rounded-lg hover:bg-gray-100 transition duration-300">开始探索</a>
                    <a href="#code-example" class="px-6 py-3 border border-white text-white font-medium rounded-lg hover:bg-white hover:bg-opacity-10 transition duration-300">查看示例</a>
                </div>
            </div>
        </div>
    </section>

    <!-- Main Content -->
    <main class="max-w-5xl mx-auto px-4 sm:px-6 lg:px-8 py-12 md:py-16">
        <!-- Introduction Section -->
        <section id="intro" class="mb-20">
            <div class="flex items-center mb-8">
                <i class="fas fa-info-circle text-indigo-500 text-2xl mr-3"></i>
                <h2 class="text-3xl font-bold">WeakHashMap 简介</h2>
            </div>
            <p class="drop-cap text-lg text-gray-700 mb-6">
                WeakHashMap 是 Java 中的一种特殊的 Map 实现，它的特点是使用<strong class="text-indigo-600">弱引用</strong>（WeakReference）作为键的引用类型，从而允许键在没有强引用存在时被垃圾回收（GC）。
            </p>
            <p class="text-lg text-gray-700 mb-8">
                这种独特的机制使得 WeakHashMap 特别适合用于缓存和临时数据存储场景，能够有效防止内存泄漏，同时保持轻量级的特性。
            </p>
            
            <div class="bg-indigo-50 border-l-4 border-indigo-500 p-4 mb-8">
                <div class="flex">
                    <div class="flex-shrink-0">
                        <i class="fas fa-lightbulb text-indigo-500"></i>
                    </div>
                    <div class="ml-3">
                        <p class="text-sm text-indigo-700">
                            <strong>关键点：</strong> WeakHashMap 的键是弱引用，当没有其他强引用指向键对象时，垃圾回收器会回收该键对象，同时 WeakHashMap 会自动移除对应的键值对。
                        </p>
                    </div>
                </div>
            </div>
        </section>

        <!-- Principle Section -->
        <section id="principle" class="mb-20">
            <div class="flex items-center mb-8">
                <i class="fas fa-cogs text-indigo-500 text-2xl mr-3"></i>
                <h2 class="text-3xl font-bold">WeakHashMap 工作原理</h2>
            </div>
            
            <h3 class="text-2xl font-semibold mt-8 mb-4">1. 核心数据结构</h3>
            <p class="text-lg text-gray-700 mb-6">
                WeakHashMap 的键被包装成 WeakReference，即每个键实际上是一个弱引用对象，而值则是正常的强引用。键值对存储在一个内部的 Entry 数组中，每个 Entry 的键是一个 WeakReference 对象，值是普通对象。
            </p>
            
            <div class="grid md:grid-cols-2 gap-8 mb-10">
                <div class="visualization-card bg-white p-6 rounded-lg shadow-md">
                    <div class="flex items-center mb-4">
                        <i class="fas fa-project-diagram text-indigo-500 mr-2"></i>
                        <h4 class="text-xl font-semibold">数据结构图</h4>
                    </div>
                    <div class="mermaid">
                        classDiagram
                            class WeakHashMap {
                                -Entry[] table
                                +get(Object key)
                                +put(K key, V value)
                                +remove(Object key)
                            }
                            class Entry {
                                -WeakReference<K> key
                                -V value
                                +getKey()
                                +getValue()
                            }
                            WeakHashMap "1" *-- "*" Entry : contains
                    </div>
                </div>
                <div class="visualization-card bg-white p-6 rounded-lg shadow-md">
                    <div class="flex items-center mb-4">
                        <i class="fas fa-recycle text-indigo-500 mr-2"></i>
                        <h4 class="text-xl font-semibold">引用关系图</h4>
                    </div>
                    <div class="mermaid">
                        flowchart LR
                            A[强引用] -->|指向| B[键对象]
                            C[WeakHashMap] -->|弱引用| B
                            D[值对象] -->|强引用| C
                            B -.->|无强引用时被 GC| E((垃圾回收))
                            E -->|通知| C
                            C -->|移除键值对| F[清理]
                    </div>
                </div>
            </div>
            
            <h3 class="text-2xl font-semibold mt-8 mb-4">2. 弱引用与垃圾回收</h3>
            <p class="text-lg text-gray-700 mb-6">
                弱引用是 Java 提供的一种引用类型，在垃圾回收时，即使弱引用的对象被引用，只要没有其他强引用指向这个对象，该对象仍会被回收。WeakHashMap 的设计依赖于这一特性。
            </p>
            
            <div class="grid md:grid-cols-2 gap-8 mb-6">
                <div class="bg-white p-6 rounded-lg shadow-sm">
                    <h4 class="text-xl font-semibold mb-4 flex items-center">
                        <i class="fas fa-link text-indigo-500 mr-2"></i>
                        强引用 vs 弱引用
                    </h4>
                    <ul class="space-y-3">
                        <li class="flex items-start">
                            <i class="fas fa-check-circle text-green-500 mt-1 mr-2"></i>
                            <span><strong>强引用</strong>：普通引用，阻止垃圾回收器回收对象</span>
                        </li>
                        <li class="flex items-start">
                            <i class="fas fa-check-circle text-green-500 mt-1 mr-2"></i>
                            <span><strong>弱引用</strong>：不会阻止垃圾回收，适合实现规范化映射</span>
                        </li>
                        <li class="flex items-start">
                            <i class="fas fa-check-circle text-green-500 mt-1 mr-2"></i>
                            <span><strong>软引用</strong>：在内存不足时才会被回收</span>
                        </li>
                        <li class="flex items-start">
                            <i class="fas fa-check-circle text-green-500 mt-1 mr-2"></i>
                            <span><strong>虚引用</strong>：主要用于跟踪对象被回收的活动</span>
                        </li>
                    </ul>
                </div>
                <div class="bg-white p-6 rounded-lg shadow-sm">
                    <h4 class="text-xl font-semibold mb-4 flex items-center">
                        <i class="fas fa-trash-alt text-indigo-500 mr-2"></i>
                        清理机制
                    </h4>
                    <ul class="space-y-3">
                        <li class="flex items-start">
                            <i class="fas fa-clock text-indigo-500 mt-1 mr-2"></i>
                            <span>定期扫描键的弱引用是否已被垃圾回收</span>
                        </li>
                        <li class="flex items-start">
                            <i class="fas fa-exchange-alt text-indigo-500 mt-1 mr-2"></i>
                            <span>通过 ReferenceQueue 检查哪些键已经被回收</span>
                        </li>
                        <li class="flex items-start">
                            <i class="fas fa-broom text-indigo-500 mt-1 mr-2"></i>
                            <span>自动删除对应键值对，保持Map的整洁</span>
                        </li>
                    </ul>
                </div>
            </div>
            
            <h3 class="text-2xl font-semibold mt-8 mb-4">3. 代码示例</h3>
            <div id="code-example" class="code-block">
                <pre class="text-gray-800"><code>// WeakHashMap 示例代码
Map&lt;Object, String&gt; map = new WeakHashMap&lt;&gt;();
Object key = new Object();
map.put(key, "value");

// 此时Map中有这个键值对
System.out.println(map.get(key)); // 输出: value

// 删除强引用
key = null;

// 强制触发垃圾回收
System.gc();

// 等待GC完成
try {
    Thread.sleep(100);
} catch (InterruptedException e) {
    e.printStackTrace();
}

// Map中的键值对已被自动清除
System.out.println(map); // 输出: {}</code></pre>
            </div>
        </section>

        <!-- Application Scenarios -->
        <section id="scenarios" class="mb-20">
            <div class="flex items-center mb-8">
                <i class="fas fa-laptop-code text-indigo-500 text-2xl mr-3"></i>
                <h2 class="text-3xl font-bold">应用场景</h2>
            </div>
            
            <div class="grid md:grid-cols-3 gap-6">
                <div class="feature-card bg-white p-6 rounded-lg shadow-md transition duration-300">
                    <div class="text-indigo-500 text-3xl mb-4">
                        <i class="fas fa-database"></i>
                    </div>
                    <h3 class="text-xl font-semibold mb-3">缓存场景</h3>
                    <p class="text-gray-600">
                        适用于存储临时数据或辅助数据，当键不再被引用时自动清理，避免内存泄漏。特别适合短期缓存场景。
                    </p>
                </div>
                
                <div class="feature-card bg-white p-6 rounded-lg shadow-md transition duration-300">
                    <div class="text-indigo-500 text-3xl mb-4">
                        <i class="fas fa-tags"></i>
                    </div>
                    <h3 class="text-xl font-semibold mb-3">元数据存储</h3>
                    <p class="text-gray-600">
                        为对象附加元信息而不影响对象的生命周期，当主对象不再使用时，元数据会自动清除。
                    </p>
                </div>
                
                <div class="feature-card bg-white p-6 rounded-lg shadow-md transition duration-300">
                    <div class="text-indigo-500 text-3xl mb-4">
                        <i class="fas fa-memory"></i>
                    </div>
                    <h3 class="text-xl font-semibold mb-3">内存敏感任务</h3>
                    <p class="text-gray-600">
                        对内存敏感的应用程序可以使用WeakHashMap存储不需要长期保留的数据，减轻内存压力。
                    </p>
                </div>
            </div>
            
            <div class="mt-10 bg-blue-50 border-l-4 border-blue-500 p-4">
                <div class="flex">
                    <div class="flex-shrink-0">
                        <i class="fas fa-exclamation-circle text-blue-500"></i>
                    </div>
                    <div class="ml-3">
                        <p class="text-sm text-blue-700">
                            <strong>注意：</strong> WeakHashMap 不适合需要长期保存数据的场景，因为键随时可能被垃圾回收。对于持久化缓存，考虑使用其他实现如 LRU Cache。
                        </p>
                    </div>
                </div>
            </div>
        </section>

        <!-- Pros & Cons -->
        <section id="pros-cons" class="mb-10">
            <div class="flex items-center mb-8">
                <i class="fas fa-balance-scale text-indigo-500 text-2xl mr-3"></i>
                <h2 class="text-3xl font-bold">优劣分析</h2>
            </div>
            
            <div class="grid md:grid-cols-2 gap-8">
                <div class="bg-white p-6 rounded-lg shadow-sm">
                    <h3 class="text-2xl font-semibold mb-6 text-green-600 flex items-center">
                        <i class="fas fa-thumbs-up mr-3"></i>
                        优点
                    </h3>
                    <ul class="space-y-4">
                        <li class="flex items-start">
                            <div class="bg-green-100 p-2 rounded-full mr-3">
                                <i class="fas fa-check text-green-600"></i>
                            </div>
                            <div>
                                <h4 class="font-medium text-lg">自动清理机制</h4>
                                <p class="text-gray-600">键对象失效后自动清除对应键值对，无需手动管理，减少内存泄漏风险。</p>
                            </div>
                        </li>
                        <li class="flex items-start">
                            <div class="bg-green-100 p-2 rounded-full mr-3">
                                <i class="fas fa-check text-green-600"></i>
                            </div>
                            <div>
                                <h4 class="font-medium text-lg">轻量级实现</h4>
                                <p class="text-gray-600">基于HashMap实现，性能开销低，适合作为辅助数据结构使用。</p>
                            </div>
                        </li>
                        <li class="flex items-start">
                            <div class="bg-green-100 p-2 rounded-full mr-3">
                                <i class="fas fa-check text-green-600"></i>
                            </div>
                            <div>
                                <h4 class="font-medium text-lg">内存效率</h4>
                                <p class="text-gray-600">能够及时释放不再使用的对象占用的内存，提高内存使用效率。</p>
                            </div>
                        </li>
                    </ul>
                </div>
                
                <div class="bg-white p-6 rounded-lg shadow-sm">
                    <h3 class="text-2xl font-semibold mb-6 text-red-600 flex items-center">
                        <i class="fas fa-thumbs-down mr-3"></i>
                        缺点
                    </h3>
                    <ul class="space-y-4">
                        <li class="flex items-start">
                            <div class="bg-red-100 p-2 rounded-full mr-3">
                                <i class="fas fa-exclamation text-red-600"></i>
                            </div>
                            <div>
                                <h4 class="font-medium text-lg">数据不可控</h4>
                                <p class="text-gray-600">键随时可能被GC回收，导致数据意外丢失，不适合需要稳定存储的场景。</p>
                            </div>
                        </li>
                        <li class="flex items-start">
                            <div class="bg-red-100 p-2 rounded-full mr-3">
                                <i class="fas fa-exclamation text-red-600"></i>
                            </div>
                            <div>
                                <h4 class="font-medium text-lg">性能影响</h4>
                                <p class="text-gray-600">需要定期清理被回收的键值对，可能对性能产生轻微影响。</p>
                            </div>
                        </li>
                        <li class="flex items-start">
                            <div class="bg-red-100 p-2 rounded-full mr-3">
                                <i class="fas fa-exclamation text-red-600"></i>
                            </div>
                            <div>
                                <h4 class="font-medium text-lg">使用限制</h4>
                                <p class="text-gray-600">仅键是弱引用，值仍然是强引用，可能导致值对象无法被回收。</p>
                            </div>
                        </li>
                    </ul>
                </div>
            </div>
            
            <div class="mt-10 bg-white p-6 rounded-lg shadow-sm">
                <h3 class="text-2xl font-semibold mb-4 flex items-center">
                    <i class="fas fa-star text-yellow-500 mr-3"></i>
                    最佳实践
                </h3>
                <ul class="list-disc pl-6 space-y-2 text-gray-700">
                    <li>适用于短期存储和缓存场景，不适用于持久化数据存储</li>
                    <li>确保不再需要键对象时才释放强引用，避免过早回收</li>
                    <li>考虑使用 WeakReference 直接管理键对象，获得更精确的控制</li>
                    <li>对于值对象较大的情况，注意可能的内存泄漏问题</li>
                    <li>在并发环境下使用 Collections.synchronizedMap 包装 WeakHashMap</li>
                </ul>
            </div>
        </section>
    </main>

    <!-- Footer -->
    <footer class="bg-gray-900 text-white py-8">
        <div class="max-w-5xl mx-auto px-4 sm:px-6 lg:px-8">
            <div class="flex flex-col md:flex-row justify-between items-center">
                <div class="mb-4 md:mb-0">
                    <h3 class="text-xl font-bold">技术小馆</h3>
                    <p class="text-gray-400 mt-1">Java 核心技术深度解析</p>
                </div>
                <div>
                    <a href="http://www.yuque.com/jtostring" class="text-indigo-400 hover:text-indigo-300 transition duration-300">www.yuque.com/jtostring</a>
                </div>
            </div>
            <div class="border-t border-gray-800 mt-8 pt-8 text-center text-gray-500 text-sm">
                &copy; 2023 技术小馆. 保留所有权利.
            </div>
        </div>
    </footer>

    <script>
        document.addEventListener('DOMContentLoaded', function() {
            // 初始化Mermaid图表
            if(typeof mermaid !== 'undefined') {
                mermaid.initialize({
                    startOnLoad: true,
                    theme: 'default',
                    flowchart: {
                        useMaxWidth: true,
                        htmlLabels: true,
                        curve: 'basis'
                    },
                    themeCSS: `
                        .node rect {
                            fill: #f8fafc;
                            stroke: #cbd5e0;
                            stroke-width: 1.5px;
                        }
                        .edgePath path {
                            stroke: #a0aec0;
                            stroke-width: 1.5px;
                        }
                    `
                });
            }
            
            // 平滑滚动
            document.querySelectorAll('a[href^="#"]').forEach(anchor => {
                anchor.addEventListener('click', function (e) {
                    e.preventDefault();
                    document.querySelector(this.getAttribute('href')).scrollIntoView({
                        behavior: 'smooth'
                    });
                });
            });
        });
    </script>
</body>
</html>
```